पाइथन पांडास में डेटाफ़्रेम को मर्ज और जॉइन करने के लिए एक विस्तृत गाइड, जिसमें वैश्विक डेटा विश्लेषण के लिए इनर, आउटर, लेफ्ट और राइट जॉइन जैसी विभिन्न रणनीतियों को व्यावहारिक उदाहरणों के साथ शामिल किया गया है।
पाइथन पांडास मर्जिंग: डेटा विश्लेषण के लिए डेटाफ़्रेम जॉइनिंग रणनीतियों में महारत हासिल करना
डेटा मैनिपुलेशन डेटा विश्लेषण का एक महत्वपूर्ण पहलू है, और पाइथन में पांडास लाइब्रेरी इस उद्देश्य के लिए शक्तिशाली उपकरण प्रदान करती है। इन उपकरणों में, डेटाफ़्रेम को मर्ज करना और जॉइन करना सामान्य कॉलम या इंडेक्स के आधार पर डेटासेट को संयोजित करने के लिए आवश्यक ऑपरेशन हैं। यह विस्तृत गाइड पांडास में विभिन्न डेटाफ़्रेम जॉइनिंग रणनीतियों की खोज करता है, जो आपको विभिन्न स्रोतों से डेटा को प्रभावी ढंग से संयोजित करने और विश्लेषण करने के ज्ञान से लैस करता है।
डेटाफ़्रेम मर्जिंग और जॉइनिंग को समझना
डेटाफ़्रेम को मर्ज और जॉइन करने में दो या दो से अधिक डेटाफ़्रेम को एक साझा कॉलम या इंडेक्स के आधार पर एक ही डेटाफ़्रेम में संयोजित करना शामिल है। `merge` और `join` के बीच मुख्य अंतर यह है कि `merge` पांडास लाइब्रेरी का एक फ़ंक्शन है और आमतौर पर डेटाफ़्रेम को कॉलम पर जॉइन करता है, जबकि `join` एक डेटाफ़्रेम मेथड है जो मुख्य रूप से इंडेक्स पर डेटाफ़्रेम को जॉइन करता है, हालांकि इसका उपयोग कॉलम के साथ भी किया जा सकता है।
मुख्य अवधारणाएँ
- डेटाफ़्रेम: दो-आयामी लेबल वाली डेटा संरचनाएं जिनमें संभावित रूप से विभिन्न प्रकार के कॉलम होते हैं।
- सामान्य कॉलम/इंडेक्स: वे कॉलम या इंडेक्स जो डेटाफ़्रेम में एक ही नाम और डेटा प्रकार साझा करते हैं, जो मर्जिंग/जॉइनिंग के आधार के रूप में काम करते हैं।
- जॉइन के प्रकार: मर्जिंग/जॉइनिंग प्रक्रिया के दौरान बेजोड़ पंक्तियों को संभालने के लिए विभिन्न रणनीतियाँ, जिनमें इनर, आउटर, लेफ्ट और राइट जॉइन शामिल हैं।
`pd.merge()` के साथ डेटाफ़्रेम मर्जिंग
`pd.merge()` फ़ंक्शन कॉलम के आधार पर डेटाफ़्रेम को मर्ज करने का प्राथमिक उपकरण है। यह एक या अधिक सामान्य कॉलम के आधार पर डेटा को संयोजित करने का एक लचीला तरीका प्रदान करता है।
सिंटैक्स
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
पैरामीटर्स
- left: मर्ज करने के लिए बायां डेटाफ़्रेम।
- right: मर्ज करने के लिए दायां डेटाफ़्रेम।
- how: किए जाने वाले मर्ज का प्रकार ('inner', 'outer', 'left', 'right')। डिफ़ॉल्ट 'inner' है।
- on: जॉइन करने के लिए कॉलम का नाम। यह दोनों डेटाफ़्रेम में पाया जाना चाहिए।
- left_on: बाएं डेटाफ़्रेम में जॉइन कीज़ के रूप में उपयोग करने के लिए कॉलम का नाम।
- right_on: दाएं डेटाफ़्रेम में जॉइन कीज़ के रूप में उपयोग करने के लिए कॉलम का नाम।
- left_index: यदि True है, तो बाएं डेटाफ़्रेम से इंडेक्स को जॉइन की (कुंजी) के रूप में उपयोग करें।
- right_index: यदि True है, तो दाएं डेटाफ़्रेम से इंडेक्स को जॉइन की (कुंजी) के रूप में उपयोग करें।
- sort: परिणामी डेटाफ़्रेम को जॉइन कीज़ द्वारा शब्दकोष के अनुसार सॉर्ट करें। डिफ़ॉल्ट False है।
- suffixes: ओवरलैपिंग कॉलम नामों पर लागू करने के लिए स्ट्रिंग सफिक्स का एक टपल। डिफ़ॉल्ट ('_x', '_y') है।
- copy: यदि False है, तो जहां संभव हो, नए डेटाफ़्रेम में डेटा कॉपी करने से बचें। डिफ़ॉल्ट True है।
- indicator: यदि True है, तो '_merge' नामक एक कॉलम जोड़ता है जो प्रत्येक पंक्ति के स्रोत को इंगित करता है।
- validate: जांचता है कि मर्ज निर्दिष्ट प्रकार का है या नहीं। "one_to_one", "one_to_many", "many_to_one", "many_to_many"।
जॉइन के प्रकारों की व्याख्या
`pd.merge()` में `how` पैरामीटर किए गए जॉइन के प्रकार को निर्धारित करता है। विभिन्न जॉइन प्रकार बेजोड़ पंक्तियों को अलग-अलग तरीकों से संभालते हैं।
इनर जॉइन
एक इनर जॉइन केवल उन पंक्तियों को लौटाता है जिनमें जॉइन कीज़ के आधार पर दोनों डेटाफ़्रेम में मेल खाने वाले मान होते हैं। बेजोड़ मानों वाली पंक्तियों को परिणाम से बाहर रखा जाता है।
उदाहरण:
दो डेटाफ़्रेम पर विचार करें:
import pandas as pd
# DataFrame 1: Customer Orders
df_orders = pd.DataFrame({
'order_id': [1, 2, 3, 4, 5],
'customer_id': [101, 102, 103, 104, 105],
'product_id': [1, 2, 1, 3, 2],
'quantity': [2, 1, 3, 1, 2]
})
# DataFrame 2: Customer Information
df_customers = pd.DataFrame({
'customer_id': [101, 102, 103, 106],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David'],
'country': ['USA', 'Canada', 'UK', 'Australia']
})
# Inner Join
df_inner = pd.merge(df_orders, df_customers, on='customer_id', how='inner')
print(df_inner)
आउटपुट:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
इस उदाहरण में, इनर जॉइन `df_orders` और `df_customers` डेटाफ़्रेम को `customer_id` कॉलम के आधार पर जोड़ता है। परिणाम में केवल वे ग्राहक शामिल हैं जिन्होंने ऑर्डर दिए हैं। ग्राहक 'डेविड' (customer_id 106) को बाहर रखा गया है क्योंकि उसके पास कोई ऑर्डर नहीं है।
आउटर जॉइन (फुल आउटर जॉइन)
एक आउटर जॉइन दोनों डेटाफ़्रेम से सभी पंक्तियों को लौटाता है, जिसमें बेजोड़ पंक्तियाँ भी शामिल हैं। यदि किसी पंक्ति का दूसरे डेटाफ़्रेम में कोई मेल नहीं है, तो संबंधित कॉलम में `NaN` (नॉट ए नंबर) मान होंगे।
उदाहरण:
# Outer Join
df_outer = pd.merge(df_orders, df_customers, on='customer_id', how='outer')
print(df_outer)
आउटपुट:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 4.0 104 3.0 1.0 NaN NaN
4 5.0 105 2.0 2.0 NaN NaN
5 NaN 106 NaN NaN David Australia
आउटर जॉइन में सभी ग्राहक और सभी ऑर्डर शामिल हैं। ग्राहक 104 और 105 के पास ऑर्डर हैं लेकिन ग्राहक जानकारी नहीं है, और ग्राहक 106 के पास ग्राहक जानकारी है लेकिन कोई ऑर्डर नहीं है। छूटे हुए मानों को `NaN` के रूप में दर्शाया गया है।
लेफ्ट जॉइन
एक लेफ्ट जॉइन बाएं डेटाफ़्रेम से सभी पंक्तियों और दाएं डेटाफ़्रेम से मेल खाने वाली पंक्तियों को लौटाता है। यदि बाएं डेटाफ़्रेम में किसी पंक्ति का दाएं डेटाफ़्रेम में कोई मेल नहीं है, तो दाएं डेटाफ़्रेम के संबंधित कॉलम में `NaN` मान होंगे।
उदाहरण:
# Left Join
df_left = pd.merge(df_orders, df_customers, on='customer_id', how='left')
print(df_left)
आउटपुट:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
लेफ्ट जॉइन में `df_orders` से सभी ऑर्डर शामिल हैं। ग्राहक 104 और 105 के पास ऑर्डर हैं लेकिन कोई ग्राहक जानकारी नहीं है, इसलिए उन ऑर्डरों के लिए `customer_name` और `country` कॉलम `NaN` हैं।
राइट जॉइन
एक राइट जॉइन दाएं डेटाफ़्रेम से सभी पंक्तियों और बाएं डेटाफ़्रेम से मेल खाने वाली पंक्तियों को लौटाता है। यदि दाएं डेटाफ़्रेम में किसी पंक्ति का बाएं डेटाफ़्रेम में कोई मेल नहीं है, तो बाएं डेटाफ़्रेम के संबंधित कॉलम में `NaN` मान होंगे।
उदाहरण:
# Right Join
df_right = pd.merge(df_orders, df_customers, on='customer_id', how='right')
print(df_right)
आउटपुट:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 NaN 106 NaN NaN David Australia
राइट जॉइन में `df_customers` से सभी ग्राहक शामिल हैं। ग्राहक 106 के पास ग्राहक जानकारी है लेकिन कोई ऑर्डर नहीं है, इसलिए उस ग्राहक के लिए `order_id`, `product_id`, और `quantity` कॉलम `NaN` हैं।
`df.join()` के साथ डेटाफ़्रेम जॉइनिंग
`df.join()` मेथड का उपयोग मुख्य रूप से डेटाफ़्रेम को उनके इंडेक्स के आधार पर जॉइन करने के लिए किया जाता है। इसका उपयोग कॉलम पर जॉइन करने के लिए भी किया जा सकता है, लेकिन कॉलम-आधारित जॉइन के लिए `pd.merge()` का उपयोग करना आमतौर पर अधिक सुविधाजनक होता है।
सिंटैक्स
DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
पैरामीटर्स
- other: जॉइन करने के लिए दूसरा डेटाफ़्रेम।
- on: जॉइन करने के लिए कॉलम का नाम। यदि इंडेक्स को जॉइन की के रूप में उपयोग नहीं किया जाता है तो इसे पास किया जाना चाहिए।
- how: बाएं और दाएं सेट के ऑपरेशन को कैसे संभालना है। डिफ़ॉल्ट 'left' है।
- lsuffix: ओवरलैपिंग कॉलम नामों को ओवरराइड करने के लिए बाएं डेटाफ़्रेम से उपयोग करने के लिए सफिक्स।
- rsuffix: ओवरलैपिंग कॉलम नामों को ओवरराइड करने के लिए दाएं डेटाफ़्रेम से उपयोग करने के लिए सफिक्स।
- sort: परिणामी डेटाफ़्रेम को जॉइन कीज़ द्वारा शब्दकोष के अनुसार सॉर्ट करें। डिफ़ॉल्ट False है।
इंडेक्स पर जॉइनिंग
इंडेक्स पर जॉइन करते समय, `on` पैरामीटर का उपयोग नहीं किया जाता है।
उदाहरण:
# DataFrame 1: Customer Orders with Customer ID as Index
df_orders_index = df_orders.set_index('customer_id')
# DataFrame 2: Customer Information with Customer ID as Index
df_customers_index = df_customers.set_index('customer_id')
# Join on Index (Left Join)
df_join_index = df_orders_index.join(df_customers_index, how='left')
print(df_join_index)
आउटपुट:
order_id product_id quantity customer_name country
customer_id
101 1 1 2 Alice USA
102 2 2 1 Bob Canada
103 3 1 3 Charlie UK
104 4 3 1 NaN NaN
105 5 2 2 NaN NaN
इस उदाहरण में, `join()` मेथड का उपयोग इंडेक्स (`customer_id`) पर लेफ्ट जॉइन करने के लिए किया जाता है। परिणाम `pd.merge()` का उपयोग करके लेफ्ट जॉइन के समान है, लेकिन जॉइन कॉलम के बजाय इंडेक्स पर आधारित है।
कॉलम पर जॉइनिंग
`df.join()` का उपयोग करके किसी कॉलम पर जॉइन करने के लिए, आपको `on` पैरामीटर निर्दिष्ट करना होगा।
उदाहरण:
# Joining on a column
df_join_column = df_orders.join(df_customers.set_index('customer_id'), on='customer_id', how='left')
print(df_join_column)
आउटपुट:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
यह उदाहरण `customer_id` कॉलम का उपयोग करके `df_orders` को `df_customers` के साथ जॉइन करना दर्शाता है। ध्यान दें कि जॉइन करने से पहले `df_customers` में `customer_id` को इंडेक्स के रूप में सेट किया गया है।
ओवरलैपिंग कॉलम को संभालना
डेटाफ़्रेम को मर्ज या जॉइन करते समय, ओवरलैपिंग कॉलम नामों (दोनों डेटाफ़्रेम में समान नाम वाले कॉलम) का सामना करना आम है। पांडास इन स्थितियों को संभालने के लिए `pd.merge()` में `suffixes` पैरामीटर और `df.join()` में `lsuffix` और `rsuffix` पैरामीटर प्रदान करता है।
`pd.merge()` में `suffixes` का उपयोग करना
`suffixes` पैरामीटर आपको उन सफिक्स को निर्दिष्ट करने की अनुमति देता है जो उन्हें अलग करने के लिए ओवरलैपिंग कॉलम नामों में जोड़े जाएंगे।
उदाहरण:
# DataFrame 1: Product Information
df_products1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C'],
'price': [10, 20, 15]
})
# DataFrame 2: Product Information (with potentially updated prices)
df_products2 = pd.DataFrame({
'product_id': [1, 2, 4],
'product_name': ['Product A', 'Product B', 'Product D'],
'price': [12, 18, 25]
})
# Merge with suffixes
df_merged_suffixes = pd.merge(df_products1, df_products2, on='product_id', suffixes=('_old', '_new'))
print(df_merged_suffixes)
आउटपुट:
product_id product_name_old price_old product_name_new price_new
0 1 Product A 10 Product A 12
1 2 Product B 20 Product B 18
इस उदाहरण में, `product_name` और `price` कॉलम दोनों डेटाफ़्रेम में मौजूद हैं। `suffixes` पैरामीटर क्रमशः बाएं और दाएं डेटाफ़्रेम से कॉलम को अलग करने के लिए `_old` और `_new` सफिक्स जोड़ता है।
`df.join()` में `lsuffix` और `rsuffix` का उपयोग करना
`lsuffix` और `rsuffix` पैरामीटर `df.join()` के लिए समान कार्यक्षमता प्रदान करते हैं। `lsuffix` बाएं डेटाफ़्रेम के ओवरलैपिंग कॉलम में जुड़ता है, और `rsuffix` दाएं डेटाफ़्रेम के।
उदाहरण:
# Join with lsuffix and rsuffix
df_products1_index = df_products1.set_index('product_id')
df_products2_index = df_products2.set_index('product_id')
df_joined_suffixes = df_products1_index.join(df_products2_index, lsuffix='_old', rsuffix='_new', how='outer')
print(df_joined_suffixes)
आउटपुट:
product_name_old price_old product_name_new price_new
product_id
1 Product A 10.0 Product A 12.0
2 Product B 20.0 Product B 18.0
3 Product C 15.0 NaN NaN
4 NaN NaN Product D 25.0
व्यावहारिक उदाहरण और उपयोग के मामले
डेटाफ़्रेम को मर्ज और जॉइन करना विभिन्न डेटा विश्लेषण परिदृश्यों में व्यापक रूप से उपयोग किया जाता है। यहाँ कुछ व्यावहारिक उदाहरण दिए गए हैं:
बिक्री डेटा को उत्पाद जानकारी के साथ जोड़ना
एक सामान्य उपयोग का मामला बिक्री डेटा को उत्पाद जानकारी के साथ जोड़ना है। मान लीजिए कि आपके पास एक डेटाफ़्रेम है जिसमें बिक्री लेनदेन हैं और दूसरा डेटाफ़्रेम है जिसमें उत्पाद विवरण हैं। आप इन डेटाफ़्रेम को मर्ज करके बिक्री डेटा को उत्पाद जानकारी से समृद्ध कर सकते हैं।
उदाहरण:
# Sales Transactions Data
df_sales = pd.DataFrame({
'transaction_id': [1, 2, 3, 4, 5],
'product_id': [101, 102, 103, 101, 104],
'quantity': [2, 1, 3, 1, 2],
'sales_date': ['2023-01-15', '2023-02-20', '2023-03-10', '2023-04-05', '2023-05-01']
})
# Product Information Data
df_products = pd.DataFrame({
'product_id': [101, 102, 103, 104],
'product_name': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'category': ['Electronics', 'Electronics', 'Electronics', 'Electronics'],
'price': [1200, 25, 75, 300]
})
# Merge Sales Data with Product Information
df_sales_enriched = pd.merge(df_sales, df_products, on='product_id', how='left')
print(df_sales_enriched)
आउटपुट:
transaction_id product_id quantity sales_date product_name category price
0 1 101 2 2023-01-15 Laptop Electronics 1200
1 2 102 1 2023-02-20 Mouse Electronics 25
2 3 103 3 2023-03-10 Keyboard Electronics 75
3 4 101 1 2023-04-05 Laptop Electronics 1200
4 5 104 2 2023-05-01 Monitor Electronics 300
परिणामी डेटाफ़्रेम `df_sales_enriched` में बिक्री लेनदेन के साथ-साथ संबंधित उत्पाद जानकारी होती है, जिससे बिक्री के रुझानों और उत्पाद प्रदर्शन का अधिक विस्तृत विश्लेषण किया जा सकता है।
ग्राहक डेटा को जनसांख्यिकीय जानकारी के साथ जोड़ना
एक और सामान्य उपयोग का मामला ग्राहक डेटा को जनसांख्यिकीय जानकारी के साथ जोड़ना है। यह जनसांख्यिकीय कारकों के आधार पर ग्राहक व्यवहार का विश्लेषण करने की अनुमति देता है।
उदाहरण:
# Customer Data
df_customers = pd.DataFrame({
'customer_id': [1, 2, 3, 4, 5],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin']
})
# Demographic Information Data
df_demographics = pd.DataFrame({
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin'],
'population': [8419000, 8982000, 13960000, 5312000, 3769000],
'average_income': [75000, 65000, 85000, 90000, 55000]
})
# Merge Customer Data with Demographic Information
df_customer_demographics = pd.merge(df_customers, df_demographics, on='city', how='left')
print(df_customer_demographics)
आउटपुट:
customer_id customer_name city population average_income
0 1 Alice New York 8419000 75000
1 2 Bob London 8982000 65000
2 3 Charlie Tokyo 13960000 85000
3 4 David Sydney 5312000 90000
4 5 Eve Berlin 3769000 55000
परिणामी डेटाफ़्रेम `df_customer_demographics` में ग्राहक डेटा के साथ-साथ उनके संबंधित शहरों की जनसांख्यिकीय जानकारी होती है, जिससे शहर की जनसांख्यिकी के आधार पर ग्राहक व्यवहार का विश्लेषण किया जा सकता है।
वैश्विक आपूर्ति श्रृंखला डेटा का विश्लेषण
पांडास मर्जिंग वैश्विक आपूर्ति श्रृंखला डेटा का विश्लेषण करने के लिए मूल्यवान है, जहां जानकारी अक्सर कई तालिकाओं में फैली होती है। उदाहरण के लिए, आपूर्तिकर्ता डेटा, शिपिंग जानकारी और बिक्री के आंकड़ों को जोड़ने से बाधाओं को उजागर किया जा सकता है और लॉजिस्टिक्स को अनुकूलित किया जा सकता है।
उदाहरण:
# Supplier Data
df_suppliers = pd.DataFrame({
'supplier_id': [1, 2, 3],
'supplier_name': ['GlobalTech', 'EuroParts', 'AsiaSource'],
'location': ['Taiwan', 'Germany', 'China']
})
# Shipping Data
df_shipments = pd.DataFrame({
'shipment_id': [101, 102, 103, 104],
'supplier_id': [1, 2, 3, 1],
'destination': ['USA', 'Canada', 'Australia', 'Japan'],
'shipment_date': ['2023-01-10', '2023-02-15', '2023-03-20', '2023-04-25']
})
# Merge Supplier and Shipment Data
df_supply_chain = pd.merge(df_shipments, df_suppliers, on='supplier_id', how='left')
print(df_supply_chain)
आउटपुट:
shipment_id supplier_id destination shipment_date supplier_name location
0 101 1 USA 2023-01-10 GlobalTech Taiwan
1 102 2 Canada 2023-02-15 EuroParts Germany
2 103 3 Australia 2023-03-20 AsiaSource China
3 104 1 Japan 2023-04-25 GlobalTech Taiwan
उन्नत मर्जिंग तकनीकें
कई कॉलम पर मर्ज करना
आप `on` पैरामीटर में कॉलम नामों की एक सूची पास करके कई कॉलम के आधार पर डेटाफ़्रेम को मर्ज कर सकते हैं।
उदाहरण:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'quantity': [10, 15, 20, 25]
})
# DataFrame 2
df2 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'price': [5, 7, 8, 10]
})
# Merge on multiple columns
df_merged_multiple = pd.merge(df1, df2, on=['product_id', 'color'], how='inner')
print(df_merged_multiple)
आउटपुट:
product_id color quantity price
0 1 red 10 5
1 1 blue 15 7
2 2 red 20 8
3 2 blue 25 10
अलग-अलग कॉलम नामों से मर्ज करना
यदि जॉइन कॉलम के नाम दो डेटाफ़्रेम में अलग-अलग हैं, तो आप मर्जिंग के लिए उपयोग किए जाने वाले कॉलम नामों को निर्दिष्ट करने के लिए `left_on` और `right_on` पैरामीटर का उपयोग कर सकते हैं।
उदाहरण:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C']
})
# DataFrame 2
df2 = pd.DataFrame({
'id': [1, 2, 4],
'price': [10, 20, 25]
})
# Merge with different column names
df_merged_different = pd.merge(df1, df2, left_on='product_id', right_on='id', how='left')
print(df_merged_different)
आउटपुट:
product_id product_name id price
0 1 Product A 1.0 10.0
1 2 Product B 2.0 20.0
2 3 Product C NaN NaN
मर्ज विश्लेषण के लिए `indicator` का उपयोग करना
`pd.merge()` में `indicator` पैरामीटर परिणामी डेटाफ़्रेम में `_merge` नामक एक कॉलम जोड़ता है, जो प्रत्येक पंक्ति के स्रोत को इंगित करता है। यह समझने के लिए उपयोगी है कि कौन सी पंक्तियाँ मेल खाती हैं और कौन सी नहीं।
उदाहरण:
# Merge with indicator
df_merged_indicator = pd.merge(df_orders, df_customers, on='customer_id', how='outer', indicator=True)
print(df_merged_indicator)
आउटपुट:
order_id customer_id product_id quantity customer_name country _merge
0 1.0 101 1.0 2.0 Alice USA both
1 2.0 102 2.0 1.0 Bob Canada both
2 3.0 103 1.0 3.0 Charlie UK both
3 4.0 104 3.0 1.0 NaN NaN left_only
4 5.0 105 2.0 2.0 NaN NaN left_only
5 NaN 106 NaN NaN David Australia right_only
`_merge` कॉलम इंगित करता है कि पंक्ति दोनों डेटाफ़्रेम (`both`), केवल बाएं डेटाफ़्रेम (`left_only`), या केवल दाएं डेटाफ़्रेम (`right_only`) से है।
मर्ज प्रकारों का सत्यापन
`validate` पैरामीटर यह सुनिश्चित करता है कि मर्ज ऑपरेशन डेटाफ़्रेम के बीच अपेक्षित संबंध प्रकारों (जैसे, 'one_to_one', 'one_to_many') के साथ संरेखित हो। यह डेटा विसंगतियों और त्रुटियों को रोकने में मदद करता है।
उदाहरण:
# Example with one-to-one validation
df_users = pd.DataFrame({
'user_id': [1, 2, 3],
'username': ['john_doe', 'jane_smith', 'peter_jones']
})
df_profiles = pd.DataFrame({
'user_id': [1, 2, 3],
'profile_description': ['Software Engineer', 'Data Scientist', 'Project Manager']
})
# Performing a one-to-one merge with validation
merged_df = pd.merge(df_users, df_profiles, on='user_id', validate='one_to_one')
print(merged_df)
यदि मर्ज निर्दिष्ट सत्यापन का उल्लंघन करता है (उदाहरण के लिए, जब 'one_to_one' निर्दिष्ट किया गया हो तो एक-से-कई संबंध), तो एक `MergeError` उत्पन्न होगा, जो आपको संभावित डेटा अखंडता मुद्दों के प्रति सचेत करेगा।
प्रदर्शन संबंधी विचार
डेटाफ़्रेम को मर्ज करना और जॉइन करना कम्प्यूटेशनल रूप से महंगा हो सकता है, खासकर बड़े डेटासेट के लिए। प्रदर्शन को बेहतर बनाने के लिए यहां कुछ युक्तियां दी गई हैं:
- उपयुक्त जॉइन प्रकार का उपयोग करें: सही जॉइन प्रकार चुनने से प्रदर्शन पर काफी प्रभाव पड़ सकता है। उदाहरण के लिए, यदि आपको केवल मेल खाने वाली पंक्तियों की आवश्यकता है, तो इनर जॉइन का उपयोग करें।
- जॉइन कॉलम को इंडेक्स करें: जॉइन कॉलम को इंडेक्स करने से मर्जिंग प्रक्रिया तेज हो सकती है।
- उपयुक्त डेटा प्रकारों का उपयोग करें: सुनिश्चित करें कि जॉइन कॉलम में संगत डेटा प्रकार हैं।
- अनावश्यक प्रतियों से बचें: `pd.merge()` और `df.join()` में `copy=False` सेट करें ताकि डेटा की अनावश्यक प्रतियां बनाने से बचा जा सके।
निष्कर्ष
डेटाफ़्रेम को मर्ज करना और जॉइन करना डेटा विश्लेषण में मौलिक ऑपरेशन हैं। विभिन्न जॉइन प्रकारों और तकनीकों को समझकर, आप विभिन्न स्रोतों से डेटा को प्रभावी ढंग से संयोजित और विश्लेषण कर सकते हैं, जिससे मूल्यवान अंतर्दृष्टि प्राप्त हो सकती है और सूचित निर्णय लेने में मदद मिल सकती है। बिक्री डेटा को उत्पाद जानकारी के साथ जोड़ने से लेकर वैश्विक आपूर्ति श्रृंखलाओं का विश्लेषण करने तक, इन तकनीकों में महारत हासिल करने से आप आत्मविश्वास के साथ जटिल डेटा मैनिपुलेशन कार्यों से निपटने में सक्षम होंगे। बड़े डेटासेट के साथ काम करते समय प्रदर्शन संबंधी प्रभावों पर विचार करना याद रखें और अधिक मजबूत और व्यावहारिक विश्लेषण के लिए `indicator` और `validate` जैसे उन्नत सुविधाओं का लाभ उठाएं।